import { ref, reactive, onUnmounted } from "vue";
import api from "@/api";

// 声明全局变量，用于存储WebSocket实例状态
let globalInstance = null;
// 防止重复输出日志的标记
let loggedDestroyedMessage = false;

// 初始化全局实例
function getGlobalInstance() {
  if (globalInstance) {
    return globalInstance;
  }

  // 创建全局实例
  globalInstance = {
    // 核心状态
    status: "disconnected",
    nodeName: "", // 聊天节点名称
    onlineCount: 0,
    onlineUsers: [],
    currentTopic: "",
    reconnectCount: 0,
    autoReconnect: true,
    eventRegistered: false, // 标记是否已注册事件处理器

    // 事件处理程序
    handlers: {
      message: [],
      statusChange: [],
      online: [],
      redPacket: [],
      systemMessage: [],
      revoke: [],
      msg: [],
      barrager: [],
      discussChanged: [],
      redPacketStatus: [],
    },

    // 其他标志
    isInitialized: false,
    socket: null,
    timers: {},
    isReconnecting: false,
  };

  // 尝试从本地缓存中恢复节点名称
  try {
    uni.getStorage({
      key: "CHAT_NODE_NAME",
      success: (res) => {
        if (res.data) {
          globalInstance.nodeName = res.data;
          console.log("从缓存恢复节点名称:", res.data);
        }
      },
    });
  } catch (e) {
    console.error("从缓存恢复节点名称失败:", e);
  }

  return globalInstance;
}

export function useChatWebSocket() {
  // 获取或初始化全局实例
  const instance = getGlobalInstance();
  console.log("获取WebSocket实例，全局状态:", instance.status);
  console.log("当前节点名称:", instance.nodeName);

  // 使用响应式包装全局状态，以便UI能反应变化
  const connectionStatus = ref(instance.status);
  const nodeName = ref(instance.nodeName);
  const onlineCount = ref(instance.onlineCount);
  const onlineUsers = ref(instance.onlineUsers);
  const currentTopic = ref(instance.currentTopic);
  const reconnectCount = ref(instance.reconnectCount);
  const autoReconnect = ref(instance.autoReconnect);

  // 添加页面状态检查变量
  const isPageVisible = ref(true);
  let pageStateCheckInterval = null;

  // 定时器引用
  let reconnectTimer = instance.timers.reconnectTimer;
  let activityTimer = instance.timers.activityTimer;
  const ACTIVITY_TIMEOUT = 30000;

  // 添加一个强制销毁标志
  let isDestroyed = false;

  // 事件回调 - 使用全局保存的处理程序
  const eventHandlers = instance.handlers;

  // 状态变更时同步到全局
  const updateGlobalStatus = (status) => {
    instance.status = status;
    connectionStatus.value = status;
  };

  // 同步其他状态到全局
  const syncToGlobal = () => {
    instance.nodeName = nodeName.value;
    instance.onlineCount = onlineCount.value;
    instance.onlineUsers = onlineUsers.value;
    instance.currentTopic = currentTopic.value;
    instance.reconnectCount = reconnectCount.value;
    instance.autoReconnect = autoReconnect.value;
    instance.timers = {
      reconnectTimer,
      activityTimer,
    };

    // 保存节点名称到本地缓存
    if (nodeName.value) {
      try {
        uni.setStorage({
          key: "CHAT_NODE_NAME",
          data: nodeName.value,
        });
      } catch (e) {
        console.error("保存节点名称到缓存失败:", e);
      }
    }
  };

  // 注册事件处理函数
  const on = (event, callback) => {
    console.log(`尝试注册事件监听器: ${event}`);

    // 检查是否是有效的事件类型
    if (!eventHandlers.hasOwnProperty(event)) {
      console.warn(`无法注册事件: ${event}，该事件类型不存在`);
      // 自动创建事件处理数组，支持动态扩展事件类型
      eventHandlers[event] = [];
      console.log(`已创建新的事件类型: ${event}`);
    }

    // 对于关键事件类型，允许重新注册同一个回调函数
    const criticalEvents = ["statusChange", "message", "online", "msg"];
    if (criticalEvents.includes(event)) {
      // 对于关键事件，先清除可能的旧回调，然后添加新回调
      const callbackStr = callback.toString();
      const existingIndex = eventHandlers[event].findIndex(
        (cb) => cb.toString() === callbackStr
      );

      if (existingIndex >= 0) {
        // 移除旧的回调
        eventHandlers[event].splice(existingIndex, 1);
        console.log(`已移除旧的${event}事件处理程序，准备重新注册`);
      }

      // 添加新的回调
      eventHandlers[event].push(callback);
      console.log(
        `关键事件${event}监听器注册成功，当前监听器数量: ${eventHandlers[event].length}`
      );

      // 标记已注册事件
      instance.eventRegistered = true;

      return true;
    }

    // 对于非关键事件，防止重复注册同一个回调函数
    const callbackStr = callback.toString();
    const exists = eventHandlers[event].some(
      (cb) => cb.toString() === callbackStr
    );

    if (exists) {
      console.warn(`回调函数已存在，跳过重复注册: ${event}`);
      return true;
    }

    // 添加回调函数到处理程序列表
    eventHandlers[event].push(callback);
    console.log(
      `事件监听器注册成功: ${event}，当前监听器数量: ${eventHandlers[event].length}`
    );

    // 如果该事件没有处理器，记录日志
    if (eventHandlers[event].length === 1) {
      console.log(`首次为事件 ${event} 添加处理器`);
    }

    // 标记已注册事件
    instance.eventRegistered = true;

    return true;
  };

  // 触发事件
  const emit = (event, data) => {
    console.log(
      `尝试触发事件: ${event}，处理器数量: ${eventHandlers[event]?.length || 0}`
    );

    // 检查是否有注册的处理程序
    if (eventHandlers[event] && eventHandlers[event].length > 0) {
      eventHandlers[event].forEach((callback) => {
        try {
          console.log(`正在执行${event}事件回调`);
          callback(data);
        } catch (e) {
          console.error(`执行${event}事件回调出错:`, e);
        }
      });
    } else {
      console.warn(`触发事件: ${event} 但没有对应的处理器`);

      // 特殊处理某些重要事件的默认行为
      if (event === "online") {
        // 确保在线状态更新
        handleOnlineUsers(data);
      } else if (event === "statusChange") {
        // 可以在这里添加状态变化的默认处理
        if (data === "connected") {
          console.log("WebSocket连接已建立，但没有状态变化处理程序");

          // 尝试从页面获取当前页面路径
          try {
            const pages = getCurrentPages();
            const currentPage = pages[pages.length - 1];
            const currentRoute = currentPage ? currentPage.route : "";

            // 检查是否在聊天页面
            if (currentRoute === "pages/chat/new-chat/index") {
              console.log("检测到在聊天页面但没有事件处理器，尝试重新初始化");

              // 设置一个延时，让页面有时间加载
              setTimeout(() => {
                // 如果页面已加载但没有注册事件处理器，可能是从其他页面返回导致的
                if (!instance.eventRegistered) {
                  console.log("尝试通知页面重新注册事件处理器");

                  // 尝试触发页面的onShow生命周期
                  try {
                    // 模拟页面刷新以触发重新注册
                    uni.$emit("chat_page_need_refresh", {
                      timestamp: Date.now(),
                    });
                  } catch (e) {
                    console.error("尝试通知页面刷新失败:", e);
                  }
                }
              }, 1000);
            }
          } catch (e) {
            console.error("检查页面路径时出错:", e);
          }
        }
      } else if (event === "msg") {
        // 对于消息类型的事件，尝试使用message事件处理
        if (eventHandlers.message && eventHandlers.message.length > 0) {
          console.log("尝试将msg类型消息转发到message事件处理器");
          emit("message", data);
        }
      }
    }
  };

  // 初始化WebSocket连接
  const initWebSocket = async () => {
    // 防止重复连接
    if (
      connectionStatus.value === "connected" ||
      connectionStatus.value === "connecting"
    ) {
      console.log("WebSocket已经处于连接或连接中状态，跳过重复连接");
      return;
    }

    // 重置销毁状态，确保在聊天页面正常初始化
    try {
      // 获取当前页面路径
      const pages = getCurrentPages();
      const currentPage = pages[pages.length - 1];
      const currentRoute = currentPage ? currentPage.route : "";

      // 如果在聊天页面，重置销毁标记
      if (currentRoute === "pages/chat/new-chat/index") {
        console.log("在聊天页面初始化WebSocket，重置销毁标记");
        isDestroyed = false;
        loggedDestroyedMessage = false;
        isPageVisible.value = true;
      }
    } catch (e) {
      console.error("检查页面路径出错:", e);
    }

    // 添加全局安全检查，确保清理掉可能存在的其他WebSocket实例
    try {
      // 检查是否存在全局WebSocket实例（比如其他页面创建的）
      if (
        globalInstance &&
        globalInstance.socket &&
        globalInstance !== instance
      ) {
        console.log("检测到其他WebSocket实例，先清理它");
        // 清理全局实例中的事件处理程序
        for (const eventType in globalInstance.handlers || {}) {
          if (globalInstance.handlers.hasOwnProperty(eventType)) {
            globalInstance.handlers[eventType] = [];
          }
        }

        // 清理全局实例的定时器
        for (const timerKey in globalInstance.timers || {}) {
          if (
            globalInstance.timers.hasOwnProperty(timerKey) &&
            globalInstance.timers[timerKey]
          ) {
            try {
              clearTimeout(globalInstance.timers[timerKey]);
              clearInterval(globalInstance.timers[timerKey]);
            } catch (e) {
              // 忽略清理错误
            }
          }
        }

        // 确保关闭连接
        try {
          uni.closeSocket({
            complete: () => {
              console.log("关闭全局WebSocket连接");
            },
          });
        } catch (e) {
          // 忽略关闭错误
        }

        // 重置全局实例状态
        globalInstance.status = "disconnected";
        globalInstance.socket = null;
        globalInstance.isReconnecting = false;
      }
    } catch (e) {
      console.error("全局WebSocket实例检查出错:", e);
    }

    // 确保先断开现有连接
    await closeWebSocket();

    updateGlobalStatus("connecting");
    emit("statusChange", connectionStatus.value);
    console.log("开始初始化WebSocket连接");

    // 检查重要事件处理程序是否已注册
    const criticalEvents = ["statusChange", "message", "online"];

    // 只在未注册事件的情况下显示警告
    if (instance.eventRegistered) {
      console.log("事件处理器已注册，跳过检查");
    } else {
      criticalEvents.forEach((eventType) => {
        if (
          !eventHandlers[eventType] ||
          eventHandlers[eventType].length === 0
        ) {
          console.warn(
            `警告: 没有注册${eventType}事件处理程序，可能导致功能异常`
          );
        } else {
          console.log(
            `${eventType}事件已注册${eventHandlers[eventType].length}个处理程序`
          );
        }
      });
    }

    // 设置连接超时检测
    let connectionTimeout = setTimeout(() => {
      if (connectionStatus.value === "connecting") {
        console.log("WebSocket连接超时，中断连接并尝试重连");
        updateGlobalStatus("disconnected");
        emit("statusChange", connectionStatus.value);
        try {
          uni.closeSocket({
            success: () => {
              console.log("关闭超时连接成功");
            },
            fail: (err) => {
              console.log("关闭超时连接失败:", err);
            },
            complete: () => {
              console.log("超时连接清理完成");
              // 重置相关状态
              instance.socket = null;
              instance.connectionTimeoutTimer = null;

              // 获取当前页面路径
              try {
                const pages = getCurrentPages();
                const currentPage = pages[pages.length - 1];
                const currentRoute = currentPage ? currentPage.route : "";

                // 检查是否在聊天相关页面
                const isChatPage =
                  currentRoute &&
                  ((currentRoute.includes("/chat/") &&
                    !currentRoute.includes("/chat/chat-detail")) ||
                    currentRoute.includes("/new-chat/") ||
                    currentRoute === "pages/chat/chat" ||
                    currentRoute === "pages/chat/new-chat/index");

                if (
                  autoReconnect.value &&
                  !instance.isReconnecting &&
                  isChatPage
                ) {
                  console.log("连接超时后触发重连");
                  setTimeout(() => {
                    handleReconnect();
                  }, 2000);
                } else {
                  console.log("当前不在聊天页面或不需要自动重连");
                }
              } catch (e) {
                console.error("检查页面路径出错，默认尝试重连", e);
                if (autoReconnect.value && !instance.isReconnecting) {
                  setTimeout(() => {
                    handleReconnect();
                  }, 2000);
                }
              }
            },
          });
        } catch (e) {
          console.log("关闭超时连接时出错", e);
          // 重置相关状态
          instance.socket = null;
          instance.connectionTimeoutTimer = null;

          // 获取当前页面路径
          try {
            const pages = getCurrentPages();
            const currentPage = pages[pages.length - 1];
            const currentRoute = currentPage ? currentPage.route : "";

            // 检查是否在聊天相关页面
            const isChatPage =
              currentRoute &&
              ((currentRoute.includes("/chat/") &&
                !currentRoute.includes("/chat/chat-detail")) ||
                currentRoute.includes("/new-chat/") ||
                currentRoute === "pages/chat/chat" ||
                currentRoute === "pages/chat/new-chat/index");

            if (autoReconnect.value && !instance.isReconnecting && isChatPage) {
              setTimeout(() => {
                handleReconnect();
              }, 2000);
            } else {
              console.log("当前不在聊天页面或不需要自动重连");
            }
          } catch (e) {
            console.error("检查页面路径出错，默认尝试重连", e);
            if (autoReconnect.value && !instance.isReconnecting) {
              setTimeout(() => {
                handleReconnect();
              }, 2000);
            }
          }
        }
      }
    }, 15000); // 增加超时时间到15秒

    // 保存定时器引用到全局实例
    instance.connectionTimeoutTimer = connectionTimeout;

    try {
      // 获取聊天节点
      let chatNodeUrl = "";
      try {
        const result = await api.chat.getChatNode();
        if (result && result.code === 0 && result.data) {
          chatNodeUrl = result.data;
          if (result.msg && result.msg !== "OK" && result.msg !== "success") {
            nodeName.value = result.msg;
          } else {
            nodeName.value = "摸鱼派聊天室";
          }
          console.log("获取到聊天室地址:", chatNodeUrl);
          console.log("聊天节点名称:", nodeName.value);
          syncToGlobal();
        } else {
          console.error("获取聊天节点信息无效:", result);
          clearTimeout(connectionTimeout);
          updateGlobalStatus("disconnected");
          emit("statusChange", connectionStatus.value);
          throw new Error("获取聊天节点地址失败");
        }
      } catch (nodeError) {
        console.error("获取聊天节点失败:", nodeError);
        clearTimeout(connectionTimeout);
        throw new Error("获取聊天节点地址失败");
      }

      if (!chatNodeUrl) {
        clearTimeout(connectionTimeout);
        throw new Error("获取聊天节点地址失败");
      }

      // 确保先移除可能存在的旧监听器
      removeSocketListeners();

      try {
        // 使用uni.connectSocket
        console.log("开始建立WebSocket连接:", chatNodeUrl);
        uni.connectSocket({
          url: chatNodeUrl,
          success: () => {
            console.log("WebSocket连接已创建，等待连接打开");
            // 保存socket引用
            instance.socket = true;

            // 建立连接后立即设置事件监听器
            setupSocketListeners();

            // 添加额外连接超时检测
            console.log("设置额外连接状态检查，6秒后检查连接是否成功打开");
            setTimeout(() => {
              // 额外检查连接是否真的建立成功
              if (connectionStatus.value === "connecting") {
                console.log("6秒后连接仍处于connecting状态，可能连接失败");
                // 可能连接未真正建立，但又没触发error事件
                handleConnectionError("连接超时(额外检查)");
              }
            }, 6000);
          },
          fail: (err) => {
            console.error("连接失败", err);
            clearTimeout(connectionTimeout);
            handleConnectionError("创建WebSocket连接失败");
          },
        });
      } catch (socketError) {
        console.error("创建WebSocket对象失败:", socketError);
        clearTimeout(connectionTimeout);
        handleConnectionError(
          "创建WebSocket连接失败: " + (socketError.message || "未知错误")
        );
      }
    } catch (error) {
      console.error("初始化WebSocket连接失败", error);
      clearTimeout(connectionTimeout);
      updateGlobalStatus("disconnected");
      emit("statusChange", connectionStatus.value);
      if (autoReconnect.value) {
        setTimeout(() => handleReconnect(), 3000);
      }
    }
  };

  // 设置WebSocket事件监听器
  const setupSocketListeners = () => {
    // 先移除可能的旧监听器
    removeSocketListeners();

    // 存储事件处理函数引用，以便后续移除
    instance.socketListeners = {
      open: (res) => {
        console.log("WebSocket连接已打开:", res);

        // 清除连接超时定时器
        if (instance.connectionTimeoutTimer) {
          clearTimeout(instance.connectionTimeoutTimer);
          instance.connectionTimeoutTimer = null;
        }

        // 更新连接状态
        updateGlobalStatus("connected");

        // 确保重置重连标记，避免死锁
        instance.isReconnecting = false;
        reconnectCount.value = 0;
        // 触发状态变化事件
        emit("statusChange", connectionStatus.value);
        // 同步状态到全局
        syncToGlobal();
        // 启动活动检测定时器
        startActivityTimer();
        // 标记为已初始化
        instance.isInitialized = true;
      },

      message: (res) => {
        try {
          // 尝试解析JSON数据
          let data;
          try {
            data = JSON.parse(res.data);
          } catch (e) {
            console.error("WebSocket消息解析失败，非JSON格式:", e);
            console.log("原始消息内容:", res.data);
            return;
          }

          console.log("WebSocket收到解析后的消息:", data);

          if (!data || !data.type) {
            console.error("收到无效的WebSocket消息数据或缺少type字段:", data);
            return;
          }

          // 调用消息处理函数
          handleWebSocketMessage(data);

          // 每次收到消息重置活动检测计时器
          resetActivityTimer();
        } catch (error) {
          console.error("处理WebSocket消息出错:", error);
        }
      },

      close: (res) => {
        console.log("WebSocket连接已关闭", res ? res : "");

        // 防止重复触发状态变更
        if (connectionStatus.value !== "disconnected") {
          updateGlobalStatus("disconnected");
          emit("statusChange", connectionStatus.value);

          // 检查是否应该自动重连
          if (autoReconnect.value && !instance.isReconnecting) {
            console.log("连接关闭，检查是否应该重连...");

            // 获取当前页面路径，以确定是否在聊天相关页面
            try {
              const pages = getCurrentPages();
              const currentPage = pages[pages.length - 1];
              const currentRoute = currentPage ? currentPage.route : "";

              // 检查是否在聊天相关页面 - 只检查新版聊天室页面
              const isChatPage = currentRoute === "pages/chat/new-chat/index";

              if (isChatPage && isPageVisible.value) {
                console.log("当前在聊天页面且页面可见，1秒后尝试重连");
                setTimeout(() => handleReconnect(), 1000);
              } else {
                console.log("当前不在聊天页面或页面不可见，暂不重连");
                // 不主动重连，等用户返回聊天页面时再重连
              }
            } catch (e) {
              console.error("检查页面路径出错，默认不重连", e);
              // 出错时不进行重连，避免无意义的连接
            }
          } else {
            console.log("未启用自动重连或已在重连过程中");
          }
        }
      },

      error: (err) => {
        console.error("WebSocket连接错误:", err);
        handleConnectionError("WebSocket连接出错");
      },
    };

    // 使用try-catch单独注册每个事件，确保一个失败不影响其他事件
    try {
      uni.onSocketOpen(instance.socketListeners.open);
      console.log("已注册socketOpen监听器");
    } catch (e) {
      console.error("注册socketOpen监听器失败:", e);
    }

    try {
      uni.onSocketMessage(instance.socketListeners.message);
      console.log("已注册socketMessage监听器");
    } catch (e) {
      console.error("注册socketMessage监听器失败:", e);
    }

    try {
      uni.onSocketClose(instance.socketListeners.close);
      console.log("已注册socketClose监听器");
    } catch (e) {
      console.error("注册socketClose监听器失败:", e);
    }

    try {
      uni.onSocketError(instance.socketListeners.error);
      console.log("已注册socketError监听器");
    } catch (e) {
      console.error("注册socketError监听器失败:", e);
    }
  };

  // 开始活动检测计时器
  const startActivityTimer = () => {
    resetActivityTimer();
  };

  // 重置活动检测计时器
  const resetActivityTimer = () => {
    if (activityTimer) {
      clearTimeout(activityTimer);
    }
    activityTimer = setTimeout(() => {
      checkConnectionStatus();
    }, ACTIVITY_TIMEOUT);

    // 更新全局定时器
    instance.timers.activityTimer = activityTimer;
  };

  // 检查连接状态
  const checkConnectionStatus = () => {
    // 如果已被销毁，不执行任何操作
    if (isDestroyed) {
      console.log("WebSocket实例已被销毁，取消状态检查");
      return;
    }

    if (connectionStatus.value === "connected") {
      try {
        console.log(
          `发送ping检测连接状态，当前时间: ${new Date().toISOString()}`
        );

        // 获取当前页面路径，检查是否在聊天相关页面
        let isChatPage = false;
        try {
          const pages = getCurrentPages();
          const currentPage = pages[pages.length - 1];
          const currentRoute = currentPage ? currentPage.route : "";

          // 检查是否在聊天相关页面 - 只检查新版聊天室页面
          isChatPage = currentRoute === "pages/chat/new-chat/index";

          console.log(`是否在聊天页面: ${isChatPage}`);
        } catch (e) {
          console.error("检查页面路径出错", e);
          isChatPage = isPageVisible.value; // 出错时使用isPageVisible状态
        }

        // 只有在聊天页面才发送ping消息
        if (!isChatPage || !isPageVisible.value) {
          console.log(
            "当前不在聊天页面或页面不可见，跳过ping检测并主动断开连接"
          );
          // 主动断开连接
          if (connectionStatus.value === "connected") {
            autoReconnect.value = false;
            closeWebSocket();
          }
          return;
        }

        // 发送ping消息
        uni.sendSocketMessage({
          data: JSON.stringify({ type: "ping" }),
          success: () => {
            console.log("Ping成功，连接正常");
            resetActivityTimer();
          },
          fail: (err) => {
            console.log("Ping失败，连接可能已断开:", err);

            // 检查连接状态
            uni.onSocketOpen((res) => {
              console.log("Socket依然处于打开状态，可能只是消息发送失败");
              uni.offSocketOpen();
            });

            uni.onSocketClose((res) => {
              console.log("Socket确实已关闭，进行重连");
              uni.offSocketClose();

              // 更新状态并尝试重连
              updateGlobalStatus("disconnected");
              emit("statusChange", connectionStatus.value);

              if (
                autoReconnect.value &&
                !instance.isReconnecting &&
                isChatPage &&
                isPageVisible.value
              ) {
                setTimeout(() => handleReconnect(), 1000);
              } else {
                console.log("未启用自动重连或不在聊天页面，不进行重连");
              }
            });

            // 手动检查连接状态
            setTimeout(() => {
              if (connectionStatus.value === "connected") {
                // 如果状态仍为connected，但ping失败，强制断开连接并重连
                console.log("连接状态异常，强制重连");
                updateGlobalStatus("disconnected");
                emit("statusChange", connectionStatus.value);

                closeWebSocket().then(() => {
                  if (
                    autoReconnect.value &&
                    !instance.isReconnecting &&
                    isChatPage &&
                    isPageVisible.value
                  ) {
                    setTimeout(() => handleReconnect(), 1000);
                  } else {
                    console.log("未启用自动重连或不在聊天页面，不进行重连");
                  }
                });
              }
            }, 2000);
          },
        });
      } catch (e) {
        console.error("发送Ping出错，连接可能已断开:", e);
        updateGlobalStatus("disconnected");
        emit("statusChange", connectionStatus.value);

        // 获取当前页面路径
        let isChatPage = false;
        try {
          const pages = getCurrentPages();
          const currentPage = pages[pages.length - 1];
          const currentRoute = currentPage ? currentPage.route : "";

          // 检查是否在聊天相关页面
          isChatPage =
            currentRoute &&
            ((currentRoute.includes("/chat/") &&
              !currentRoute.includes("/chat/chat-detail")) ||
              currentRoute.includes("/new-chat/") ||
              currentRoute === "pages/chat/chat" ||
              currentRoute === "pages/chat/new-chat/index");
        } catch (e) {
          console.error("检查页面路径出错", e);
          isChatPage = isPageVisible.value; // 出错时使用isPageVisible状态
        }

        if (
          autoReconnect.value &&
          !instance.isReconnecting &&
          isChatPage &&
          isPageVisible.value
        ) {
          setTimeout(() => handleReconnect(), 1000);
        } else {
          console.log("未启用自动重连或不在聊天页面，不进行重连");
        }
      }
    } else if (
      connectionStatus.value === "disconnected" &&
      autoReconnect.value &&
      !instance.isReconnecting &&
      isPageVisible.value
    ) {
      // 如果已断开但应该自动重连，则尝试重连，但仅当页面可见时
      // 获取当前页面路径
      let isChatPage = false;
      try {
        const pages = getCurrentPages();
        const currentPage = pages[pages.length - 1];
        const currentRoute = currentPage ? currentPage.route : "";

        // 检查是否在聊天相关页面
        isChatPage =
          currentRoute &&
          ((currentRoute.includes("/chat/") &&
            !currentRoute.includes("/chat/chat-detail")) ||
            currentRoute.includes("/new-chat/") ||
            currentRoute === "pages/chat/chat" ||
            currentRoute === "pages/chat/new-chat/index");
      } catch (e) {
        console.error("检查页面路径出错", e);
        isChatPage = true;
      }

      if (isChatPage && isPageVisible.value) {
        console.log("检测到连接已断开，且在聊天页面，触发自动重连");
        setTimeout(() => handleReconnect(), 1000);
      } else {
        console.log("检测到连接已断开，但不在聊天页面或页面不可见，暂不重连");
      }
    }
  };

  // 处理连接错误
  const handleConnectionError = (errorMsg) => {
    console.error(errorMsg);

    // 更新状态但避免重复触发
    if (connectionStatus.value !== "disconnected") {
      updateGlobalStatus("disconnected");
      emit("statusChange", connectionStatus.value);
    }

    // 输出当前重连状态，便于调试
    console.log(
      `当前自动重连状态: ${autoReconnect.value}, 正在重连: ${instance.isReconnecting}`
    );

    // 获取当前页面路径，检查是否在聊天相关页面
    let isChatPage = false;
    try {
      const pages = getCurrentPages();
      const currentPage = pages[pages.length - 1];
      const currentRoute = currentPage ? currentPage.route : "";
      console.log(`当前页面路径: ${currentRoute}`);

      // 检查是否在聊天相关页面 - 只检查新版聊天室页面
      isChatPage = currentRoute === "pages/chat/new-chat/index";

      console.log(`是否在聊天页面: ${isChatPage}`);
    } catch (e) {
      console.error("检查页面路径出错，默认不在聊天页面", e);
      isChatPage = false; // 出错时默认不在聊天页面，避免不必要的连接
    }

    // 如果重连标志被关闭，但确实在聊天页面，强制启用重连
    if (!autoReconnect.value && isChatPage && isPageVisible.value) {
      console.log("检测到在聊天页面但重连标志关闭，强制启用重连");
      autoReconnect.value = true;
      syncToGlobal();
    }

    // 只有在启用自动重连且未处于重连过程中且在聊天页面时才重连
    if (
      autoReconnect.value &&
      !instance.isReconnecting &&
      isChatPage &&
      isPageVisible.value
    ) {
      console.log("连接出错，将尝试自动重连");
      setTimeout(() => handleReconnect(), 1000);
    } else {
      // 输出详细原因，便于排查
      let reason = [];
      if (!autoReconnect.value) reason.push("未启用自动重连");
      if (instance.isReconnecting) reason.push("已在重连过程中");
      if (!isChatPage) reason.push("不在聊天页面");
      if (!isPageVisible.value) reason.push("页面不可见");

      console.log(`未触发重连原因: ${reason.join(", ")}`);
    }
  };

  // 处理重连逻辑
  const handleReconnect = () => {
    // 如果已被销毁，不执行任何操作
    if (isDestroyed) {
      console.log("WebSocket实例已被销毁，取消重连");
      return;
    }

    // 输出当前重连状态，便于调试
    console.log(
      `重连检查 - 当前状态: ${connectionStatus.value}, 自动重连: ${autoReconnect.value}, 正在重连: ${instance.isReconnecting}, 页面可见: ${isPageVisible.value}`
    );

    // 如果页面不可见，不进行重连
    if (!isPageVisible.value) {
      console.log("页面不可见，跳过重连");
      return;
    }

    // 如果当前已处于连接或连接中状态，不需要重连
    if (
      connectionStatus.value === "connected" ||
      connectionStatus.value === "connecting"
    ) {
      console.log(`当前已处于${connectionStatus.value}状态，不需要重连`);
      return;
    }

    // 防止在重连中再次触发重连
    if (instance.isReconnecting) {
      console.log("重连过程已在进行中，避免重复重连");
      return;
    }

    // 设置重连标记
    instance.isReconnecting = true;
    console.log("已设置重连标记");

    // 使用指数退避策略定义重连延迟时间（毫秒）
    const RECONNECT_DELAYS = [1000, 2000, 3000, 5000, 8000, 13000, 21000];

    // 重连计数限制
    const MAX_RECONNECT_ATTEMPTS = 10;

    // 如果已达到最大重连次数，停止重连
    if (reconnectCount.value >= MAX_RECONNECT_ATTEMPTS) {
      console.log(`达到最大重连次数(${reconnectCount.value})，放弃自动重连`);
      instance.isReconnecting = false;
      return;
    }

    console.log(`准备第${reconnectCount.value + 1}次重连...`);

    // 计算当前应该使用的延迟时间
    const delayIndex = Math.min(
      reconnectCount.value,
      RECONNECT_DELAYS.length - 1
    );
    const delay = RECONNECT_DELAYS[delayIndex];

    console.log(`将在${delay}ms后尝试重连`);

    // 确保清理旧的重连定时器
    if (reconnectTimer) {
      clearTimeout(reconnectTimer);
      reconnectTimer = null;
    }

    // 强制设置自动重连标记为真
    autoReconnect.value = true;
    syncToGlobal();

    // 先确保关闭旧的连接
    try {
      uni.closeSocket({
        complete: () => {
          console.log("重连前已清理旧连接");

          // 设置延迟，避免立即重连
          reconnectTimer = setTimeout(() => {
            // 在延迟后再次检查页面可见状态
            if (!isPageVisible.value) {
              console.log("延迟后页面已不可见，取消重连");
              instance.isReconnecting = false;
              return;
            }

            try {
              console.log(`开始第${reconnectCount.value + 1}次重连`);
              reconnectCount.value++; // 增加重连计数
              syncToGlobal(); // 同步状态到全局

              // 重新初始化连接
              console.log("调用initWebSocket开始重连");
              initWebSocket().finally(() => {
                // 无论成功失败，重置重连标记
                console.log("重连initWebSocket执行完成，重置重连标记");
                instance.isReconnecting = false;
              });
            } catch (error) {
              console.error("重连过程中发生错误:", error);
              instance.isReconnecting = false;

              // 继续尝试重连
              if (autoReconnect.value && isPageVisible.value) {
                console.log("重连出错，3秒后再次尝试");
                reconnectTimer = setTimeout(() => {
                  handleReconnect();
                }, 3000);
              }
            }
          }, delay);

          // 保存定时器引用
          instance.timers.reconnectTimer = reconnectTimer;
        },
      });
    } catch (error) {
      console.error("关闭旧连接出错:", error);
      instance.isReconnecting = false;

      // 仍然尝试重连
      reconnectTimer = setTimeout(() => {
        // 再次检查页面可见状态
        if (!isPageVisible.value) {
          console.log("延迟后页面已不可见，取消重连");
          return;
        }

        try {
          console.log("关闭连接失败后尝试重连");
          reconnectCount.value++; // 增加重连计数
          syncToGlobal(); // 同步状态到全局
          initWebSocket();
        } catch (error) {
          console.error("重连过程中发生错误:", error);
          instance.isReconnecting = false;
        }
      }, delay);

      // 保存定时器引用
      instance.timers.reconnectTimer = reconnectTimer;
    }
  };

  // 手动重连
  const manualReconnect = async () => {
    console.log("开始手动重连");

    // 完全重置状态
    reconnectCount.value = 0;
    instance.isReconnecting = false;

    // 确保关闭当前连接
    await closeWebSocket();

    // 启用自动重连
    autoReconnect.value = true;
    syncToGlobal();

    // 输出当前状态
    console.log(
      `手动重连 - 当前状态: ${connectionStatus.value}, 自动重连: ${autoReconnect.value}, 正在重连: ${instance.isReconnecting}`
    );

    // 添加随机延迟避免多用户同时重连
    const randomDelay = Math.floor(Math.random() * 500); // 减少延迟时间
    console.log(`将在${randomDelay}ms后开始重新连接`);

    // 延迟重连，给系统一些时间完全清理旧连接
    setTimeout(() => {
      try {
        console.log("手动重连延迟结束，开始调用initWebSocket");
        // 直接调用初始化方法
        initWebSocket().catch((error) => {
          console.error("手动重连初始化失败:", error);
          // 如果失败，再次尝试
          setTimeout(() => {
            console.log("第一次失败后再次尝试重连");
            initWebSocket();
          }, 1000);
        });
      } catch (error) {
        console.error("手动重连过程中出错:", error);
        // 显示错误消息，但不再尝试自动重连
        updateGlobalStatus("disconnected");
        emit("statusChange", connectionStatus.value);
      }
    }, randomDelay);
  };

  // 处理WebSocket消息
  const handleWebSocketMessage = (data) => {
    if (!data) {
      console.error("收到无效的WebSocket消息数据");
      return;
    }

    const messageType = data.type;
    if (!messageType) {
      console.error("收到的消息没有type字段:", data);
      return;
    }

    console.log(
      `准备处理类型为 ${messageType} 的WebSocket消息，处理器数量: ${
        eventHandlers[messageType]?.length || 0
      }`
    );

    // 从特殊消息中提取节点名称信息
    if (
      messageType === "online" ||
      messageType === "welcome" ||
      messageType === "init"
    ) {
      // 这些类型的消息可能包含节点名信息
      if (data.chatRoomName || data.roomName || data.nodeName) {
        const extractedNodeName =
          data.chatRoomName || data.roomName || data.nodeName;
        if (extractedNodeName && extractedNodeName !== "暂无") {
          nodeName.value = extractedNodeName;
          console.log("从消息中提取节点名:", nodeName.value);
          syncToGlobal();
        }
      }
    }

    // 对online类型消息特殊处理，更新本地状态
    if (messageType === "online") {
      handleOnlineUsers(data);
    }

    // 如果收到pong消息，说明连接正常，不需要额外处理
    if (messageType === "pong") {
      console.log("收到服务器pong响应，连接状态正常");
      resetActivityTimer();
      return;
    }

    // 收到对方已下线消息时，不触发事件，只打印日志
    if (messageType === "offline") {
      console.log("收到用户下线消息:", data);
      return;
    }

    // 消息类型映射表，用于将某些消息类型转发至其他处理器
    const messageTypeMap = {
      msg: "message",
      redPacketStatus: "redPacket",
      barrager: "barrager", // 弹幕消息类型映射
      customMessage: "systemMessage", // 自定义消息类型映射为系统消息
      redPacket: "redPacket", // 添加红包消息类型映射
      online: "online", // 确保online消息类型也有映射
      discussChanged: "discussChanged", // 讨论主题变更映射
      revoke: "revoke", // 消息撤回映射
      // 可添加其他映射关系
    };

    // 特殊处理红包相关消息
    if (messageType === "redPacketStatus" || messageType === "redPacket") {
      console.log(`特殊处理红包相关消息类型: ${messageType}`);

      // 尝试直接使用redPacket事件处理
      if (eventHandlers.redPacket && eventHandlers.redPacket.length > 0) {
        console.log(`将${messageType}类型消息转发到redPacket事件处理器`);
        data._originalType = messageType;
        emit("redPacket", data);
        return;
      }
    }

    // 尝试直接触发事件
    if (eventHandlers[messageType] && eventHandlers[messageType].length > 0) {
      // 触发对应类型的事件
      emit(messageType, data);
      return; // 已处理，直接返回
    }

    // 尝试使用映射类型进行处理
    const mappedType = messageTypeMap[messageType];
    if (
      mappedType &&
      eventHandlers[mappedType] &&
      eventHandlers[mappedType].length > 0
    ) {
      console.log(
        `将 ${messageType} 类型消息映射为 ${mappedType} 类型进行处理`
      );
      // 保留原始类型信息
      data._originalType = messageType;
      // 转发到映射的事件处理器
      emit(mappedType, data);
      return; // 已处理，直接返回
    }

    // 特殊处理 msg 类型消息 (针对历史代码兼容)
    if (messageType === "msg") {
      console.log("尝试特殊处理 msg 类型消息");
      // 尝试触发通用 message 事件
      if (eventHandlers.message && eventHandlers.message.length > 0) {
        data._originalType = "msg";
        emit("message", data);
        return;
      }
    }

    // 添加红包相关的特殊处理兜底逻辑
    if (messageType === "redPacketStatus" || messageType === "redPacket") {
      console.log(`红包消息没有对应的处理器，尝试不同映射`);

      // 如果没有redPacket处理器，尝试message处理器
      if (eventHandlers.message && eventHandlers.message.length > 0) {
        console.log(`尝试将红包消息转发到message事件处理器`);
        data._originalType = messageType;
        data._isRedPacketMessage = true;
        emit("message", data);
        return;
      }
    }

    // 未处理的消息类型
    console.warn(`无法处理的消息类型: ${messageType}，没有对应的处理器`);
    console.log("未处理消息内容:", JSON.stringify(data));
  };

  // 处理在线用户信息
  const handleOnlineUsers = (message) => {
    if (message.onlineChatCnt !== undefined) {
      onlineCount.value = message.onlineChatCnt;
    }

    if (message.users) {
      onlineUsers.value = message.users;
    }

    if (message.discussing) {
      currentTopic.value =
        message.discussing !== "暂无" ? message.discussing : "";
    }

    // 如果消息中包含节点名，更新节点名
    if (message.nodeName) {
      nodeName.value = message.nodeName;
      console.log("从online消息更新节点名:", nodeName.value);
    } else if (message.roomName) {
      nodeName.value = message.roomName;
      console.log("从online消息的roomName更新节点名:", nodeName.value);
    } else if (message.chatRoomName) {
      nodeName.value = message.chatRoomName;
      console.log("从online消息的chatRoomName更新节点名:", nodeName.value);
    }

    // 同步到全局状态
    syncToGlobal();
  };

  // 发送消息
  const sendMessage = (content) => {
    return new Promise((resolve, reject) => {
      if (connectionStatus.value !== "connected") {
        reject(new Error("聊天室连接已断开，请等待重连"));
        return;
      }

      try {
        console.log("准备发送消息:", content);
        api.chat
          .sendMessage(content)
          .then((res) => {
            console.log("消息发送响应:", res);
            if (res.code === 0) {
              // 发送成功后，直接处理返回的消息对象 (如果有)
              if (res.data && res.data.oId) {
                console.log("服务器返回了消息对象，尝试直接处理", res.data);
                try {
                  // 创建一个符合消息格式的对象
                  const messageEvent = {
                    type: "message",
                    data: res.data,
                  };
                  // 使用已有的消息处理函数处理
                  handleWebSocketMessage(messageEvent);
                } catch (e) {
                  console.error("处理返回的消息对象失败:", e);
                }
              }
              resolve(res.data);
            } else {
              reject(new Error(res.msg || "发送消息失败"));
            }
          })
          .catch((error) => {
            console.error("发送消息异常:", error);
            reject(error);
          });
      } catch (error) {
        console.error("发送消息异常:", error);
        reject(error);
      }
    });
  };

  // 关闭WebSocket连接
  const closeWebSocket = async () => {
    try {
      console.log("关闭WebSocket连接");

      // 记录当前页面状态，如果在聊天页面则保持自动重连标记
      let shouldKeepReconnect = false;
      try {
        const pages = getCurrentPages() || [];
        if (!pages || pages.length === 0) {
          console.log("getCurrentPages返回空值，可能在非页面环境");
        } else {
          const currentPage = pages[pages.length - 1];
          if (!currentPage) {
            console.log("无法获取当前页面");
          } else {
            const currentRoute = currentPage.route || "";
            // 检查是否在聊天相关页面 - 只检查新版聊天室页面
            shouldKeepReconnect = currentRoute === "pages/chat/new-chat/index";

            console.log(
              `关闭WebSocket - 当前页面: ${currentRoute}, 保持重连标记: ${shouldKeepReconnect}`
            );
          }
        }
      } catch (e) {
        console.error("检查页面路径出错", e);
      }

      // 仅在非聊天页面时关闭自动重连
      if (!shouldKeepReconnect) {
        autoReconnect.value = false;
        console.log("非聊天页面，关闭自动重连标记");
      } else {
        console.log("当前在聊天页面，保持自动重连标记:", autoReconnect.value);
      }

      syncToGlobal();

      if (reconnectTimer) {
        clearTimeout(reconnectTimer);
        reconnectTimer = null;
        instance.timers.reconnectTimer = null;
      }

      if (activityTimer) {
        clearTimeout(activityTimer);
        activityTimer = null;
        instance.timers.activityTimer = null;
      }

      // 先移除所有事件监听器，避免在关闭过程中触发事件
      try {
        removeSocketListeners();
      } catch (e) {
        console.error("移除监听器失败:", e);
      }

      updateGlobalStatus("disconnected");
      emit("statusChange", connectionStatus.value);

      // 确保socket引用被重置
      instance.socket = null;

      return new Promise((resolve) => {
        try {
          if (uni.closeSocket) {
            uni.closeSocket({
              success: () => {
                console.log("WebSocket连接已成功关闭");
                resolve(true);
              },
              fail: (err) => {
                console.log("关闭WebSocket连接失败，可能已经断开", err);
                resolve(false);
              },
              complete: () => {
                // 确保在任何情况下都清理状态
                updateGlobalStatus("disconnected");
                emit("statusChange", connectionStatus.value);

                // 延迟一下再重置重连状态，避免与关闭逻辑冲突
                setTimeout(() => {
                  instance.isReconnecting = false;
                }, 500);

                resolve(true);
              },
            });
          } else {
            console.log("uni.closeSocket方法不存在");
            // 确保在错误情况下也清理状态
            setTimeout(() => {
              instance.isReconnecting = false;
            }, 500);
            resolve(false);
          }
        } catch (error) {
          console.error("关闭WebSocket时出错", error);
          // 确保在错误情况下也清理状态
          updateGlobalStatus("disconnected");
          emit("statusChange", connectionStatus.value);

          // 延迟一下再重置重连状态，避免与关闭逻辑冲突
          setTimeout(() => {
            instance.isReconnecting = false;
          }, 500);

          resolve(false);
        }
      });
    } catch (error) {
      console.error("closeWebSocket函数执行失败:", error);
      // 确保在错误情况下也返回一个Promise
      return Promise.resolve(false);
    }
  };

  // 移除WebSocket事件监听器
  const removeSocketListeners = () => {
    try {
      console.log("正在移除WebSocket事件监听器");

      // 检查是否存在之前保存的监听器引用
      if (instance.socketListeners) {
        // 尝试使用uni.offSocketXXX方法
        // 如果不支持，则传入对应的函数引用
        try {
          if (typeof uni.offSocketOpen === "function") {
            uni.offSocketOpen();
          } else if (instance.socketListeners.open) {
            uni.offSocketOpen &&
              uni.offSocketOpen(instance.socketListeners.open);
          }
          console.log("已尝试移除socketOpen监听器");
        } catch (e) {
          console.error("移除socketOpen监听器失败:", e);
        }

        try {
          if (typeof uni.offSocketMessage === "function") {
            uni.offSocketMessage();
          } else if (instance.socketListeners.message) {
            uni.offSocketMessage &&
              uni.offSocketMessage(instance.socketListeners.message);
          }
          console.log("已尝试移除socketMessage监听器");
        } catch (e) {
          console.error("移除socketMessage监听器失败:", e);
        }

        try {
          if (typeof uni.offSocketClose === "function") {
            uni.offSocketClose();
          } else if (instance.socketListeners.close) {
            uni.offSocketClose &&
              uni.offSocketClose(instance.socketListeners.close);
          }
          console.log("已尝试移除socketClose监听器");
        } catch (e) {
          console.error("移除socketClose监听器失败:", e);
        }

        try {
          if (typeof uni.offSocketError === "function") {
            uni.offSocketError();
          } else if (instance.socketListeners.error) {
            uni.offSocketError &&
              uni.offSocketError(instance.socketListeners.error);
          }
          console.log("已尝试移除socketError监听器");
        } catch (e) {
          console.error("移除socketError监听器失败:", e);
        }

        // 清空监听器引用
        instance.socketListeners = null;
      }

      console.log("WebSocket监听器清理完成");
    } catch (error) {
      console.error("移除WebSocket监听器时出错:", error);
    }
  };

  // 添加自动恢复监控定时器
  let recoveryMonitorTimer = null;

  // 开始自动恢复监控
  const startRecoveryMonitor = () => {
    // 先清除可能存在的监控器
    if (recoveryMonitorTimer) {
      clearInterval(recoveryMonitorTimer);
    }

    // 设置新的监控器，每20秒检查一次连接状态
    recoveryMonitorTimer = setInterval(() => {
      // 只在断开连接且未在重连过程中时检查
      if (
        connectionStatus.value === "disconnected" &&
        !instance.isReconnecting &&
        isPageVisible.value // 增加页面可见检查
      ) {
        console.log("恢复监控触发 - 检测到连接已断开且未在重连过程中");

        // 获取当前页面路径
        try {
          const pages = getCurrentPages();
          const currentPage = pages[pages.length - 1];
          const currentRoute = currentPage ? currentPage.route : "";

          // 检查是否在聊天相关页面 - 只检查新版聊天室页面
          const isChatPage = currentRoute === "pages/chat/new-chat/index";

          console.log(
            `恢复监控 - 当前页面: ${currentRoute}, 是否聊天页面: ${isChatPage}, 页面可见: ${isPageVisible.value}`
          );

          if (isChatPage && isPageVisible.value) {
            console.log("恢复监控 - 在聊天页面检测到断开连接，尝试恢复");
            // 重置自动重连标志并触发重连
            autoReconnect.value = true;
            instance.isReconnecting = false;
            syncToGlobal();

            // 延迟调用重连函数
            setTimeout(() => {
              handleReconnect();
            }, 1000);
          } else {
            console.log("恢复监控 - 不在聊天页面或页面不可见，不进行恢复");
          }
        } catch (e) {
          console.error("恢复监控 - 检查页面出错", e);
        }
      }
    }, 20000); // 每20秒检查一次

    // 保存定时器引用
    instance.timers.recoveryMonitorTimer = recoveryMonitorTimer;
  };

  // 停止恢复监控
  const stopRecoveryMonitor = () => {
    if (recoveryMonitorTimer) {
      clearInterval(recoveryMonitorTimer);
      recoveryMonitorTimer = null;
      instance.timers.recoveryMonitorTimer = null;
    }
  };

  // 添加页面状态检查函数
  const startPageStateCheck = () => {
    try {
      // 如果已被销毁，不启动检查
      if (isDestroyed) {
        console.log("实例已销毁，不启动页面状态检查");
        return;
      }

      // 先清除可能存在的定时器
      if (pageStateCheckInterval) {
        clearInterval(pageStateCheckInterval);
        pageStateCheckInterval = null;
      }

      // 设置新的检查定时器
      pageStateCheckInterval = setInterval(() => {
        try {
          // 如果已被销毁，停止检查
          if (isDestroyed) {
            // 使用防重复日志标记
            if (!loggedDestroyedMessage) {
              console.log("实例已被销毁，停止页面状态检查");
              loggedDestroyedMessage = true;
            }

            if (pageStateCheckInterval) {
              clearInterval(pageStateCheckInterval);
              pageStateCheckInterval = null;
            }
            return;
          }

          // 如果执行到这里，说明实例未被销毁，重置日志标记
          loggedDestroyedMessage = false;

          const pages = getCurrentPages() || [];
          if (!pages || pages.length === 0) {
            console.log("getCurrentPages返回空值，可能在非页面环境");
            return;
          }

          const currentPage = pages[pages.length - 1];
          if (!currentPage) {
            console.log("无法获取当前页面，跳过检查");
            return;
          }

          const currentRoute = currentPage.route || "";
          if (!currentRoute) {
            console.log("当前页面路由为空，跳过检查");
            return;
          }

          // 检查是否在聊天室页面 - 只检查新版聊天室页面
          const isChatPage = currentRoute === "pages/chat/new-chat/index";

          if (!isChatPage && isPageVisible.value) {
            // 如果离开了聊天室页面，标记为不可见并彻底销毁
            console.log("已离开聊天室页面，标记为不可见，彻底销毁WebSocket");
            isPageVisible.value = false;
            autoReconnect.value = false;
            destroyCompletely(); // 使用新的彻底销毁方法
          } else if (isChatPage && !isPageVisible.value && !isDestroyed) {
            // 如果回到了聊天室页面，标记为可见并重新连接
            console.log("已回到聊天室页面，标记为可见，重新连接WebSocket");
            isPageVisible.value = true;
            autoReconnect.value = true;
            // 重置销毁标志
            isDestroyed = false;
            if (connectionStatus.value === "disconnected") {
              initWebSocket();
            }
          } else if (isChatPage && isDestroyed) {
            // 如果在聊天室页面但实例已被销毁，尝试重新初始化
            console.log(
              "检测到在聊天室页面但WebSocket已被销毁，尝试重置并重新连接"
            );
            isPageVisible.value = true;
            autoReconnect.value = true;
            isDestroyed = false; // 重置销毁标志

            // 清理定时器避免重复输出日志
            if (pageStateCheckInterval) {
              clearInterval(pageStateCheckInterval);
              pageStateCheckInterval = null;

              // 重新启动页面状态检查（延迟1秒）
              setTimeout(() => {
                startPageStateCheck();
                // 尝试重新连接
                initWebSocket();
              }, 1000);
              return; // 提前返回避免继续执行
            }
          }
        } catch (e) {
          console.error("页面状态检查出错:", e);
          // 如果出错，保守处理，销毁实例
          try {
            destroyCompletely();
          } catch (err) {
            console.error("尝试销毁实例时出错:", err);
          }
        }
      }, 1000); // 每1秒检查一次

      // 保存定时器引用
      if (instance.timers) {
        instance.timers.pageStateCheckInterval = pageStateCheckInterval;
      }
    } catch (e) {
      console.error("启动页面状态检查出错:", e);
    }
  };

  // 停止页面状态检查
  const stopPageStateCheck = () => {
    try {
      console.log("执行stopPageStateCheck函数");
      if (pageStateCheckInterval) {
        console.log("正在清除页面状态检查定时器");
        clearInterval(pageStateCheckInterval);
        pageStateCheckInterval = null;
        if (instance.timers) {
          instance.timers.pageStateCheckInterval = null;
        }
        console.log("页面状态检查定时器已清除");
      } else {
        console.log("页面状态检查定时器已为空，无需清除");
      }
    } catch (e) {
      console.error("停止页面状态检查出错:", e);
    }
  };

  // 在初始化后启动恢复监控和页面状态检查
  startRecoveryMonitor();
  startPageStateCheck();

  // 完全销毁WebSocket实例和所有相关资源
  const destroyCompletely = () => {
    try {
      console.log("完全销毁WebSocket实例和所有相关资源");

      // 设置销毁标志
      isDestroyed = true;

      // 清除所有事件处理程序
      try {
        console.log("清除所有事件处理程序");
        // 遍历所有事件类型
        for (const eventType in eventHandlers) {
          if (
            eventHandlers.hasOwnProperty(eventType) &&
            Array.isArray(eventHandlers[eventType])
          ) {
            console.log(`清除事件类型 ${eventType} 的所有处理程序`);
            // 清空该事件类型的所有处理程序
            eventHandlers[eventType] = [];
          }
        }

        // 重置事件注册标志
        instance.eventRegistered = false;
      } catch (e) {
        console.error("清除事件处理程序出错:", e);
      }

      // 停止所有定时器
      try {
        console.log("尝试停止页面状态检查");
        // 直接清除页面状态检查定时器，避免依赖stopPageStateCheck函数
        if (pageStateCheckInterval) {
          clearInterval(pageStateCheckInterval);
          pageStateCheckInterval = null;
          console.log("已直接清除页面状态检查定时器");
        }
        // 再调用停止函数以确保完全清理
        stopPageStateCheck();
      } catch (e) {
        console.error("停止页面状态检查出错:", e);
      }

      try {
        stopRecoveryMonitor();
      } catch (e) {
        console.error("停止恢复监控出错:", e);
      }

      if (reconnectTimer) {
        clearTimeout(reconnectTimer);
        reconnectTimer = null;
      }

      if (activityTimer) {
        clearTimeout(activityTimer);
        activityTimer = null;
      }

      if (instance.connectionTimeoutTimer) {
        clearTimeout(instance.connectionTimeoutTimer);
        instance.connectionTimeoutTimer = null;
      }

      // 清除所有可能的定时器
      if (instance.timers) {
        Object.values(instance.timers).forEach((timer) => {
          if (timer) {
            try {
              clearTimeout(timer);
              clearInterval(timer);
            } catch (e) {
              console.error("清除定时器出错:", e);
            }
          }
        });
        instance.timers = {};
      }

      // 强制关闭WebSocket连接
      try {
        if (uni.closeSocket) {
          uni.closeSocket({
            complete: () => {
              console.log("WebSocket连接已关闭");
            },
          });
        }
      } catch (e) {
        console.error("关闭WebSocket连接出错", e);
      }

      // 移除所有事件监听器
      try {
        removeSocketListeners();
      } catch (e) {
        console.error("移除事件监听器出错:", e);
      }

      // 重置实例状态
      instance.socket = null;
      instance.isReconnecting = false;
      instance.status = "disconnected";
      connectionStatus.value = "disconnected";
      autoReconnect.value = false;

      console.log("WebSocket实例销毁完成");
    } catch (error) {
      console.error("销毁WebSocket实例时发生错误:", error);
    }
  };

  // 添加取消事件注册的功能
  const off = (event, callback) => {
    try {
      console.log(`尝试取消注册事件监听器: ${event}`);

      // 检查是否是有效的事件类型
      if (!eventHandlers.hasOwnProperty(event)) {
        console.warn(`无法取消注册事件: ${event}，该事件类型不存在`);
        return false;
      }

      // 如果没有提供回调函数，清除该事件的所有处理程序
      if (!callback) {
        console.log(`清除事件 ${event} 的所有处理程序`);
        eventHandlers[event] = [];
        return true;
      }

      // 查找并移除特定回调函数
      const callbackStr = callback.toString();
      const index = eventHandlers[event].findIndex(
        (cb) => cb.toString() === callbackStr
      );

      if (index >= 0) {
        // 找到匹配的回调函数，移除它
        eventHandlers[event].splice(index, 1);
        console.log(`已从 ${event} 事件中移除回调函数`);
        return true;
      } else {
        console.warn(`未找到要取消注册的回调函数: ${event}`);
        return false;
      }
    } catch (e) {
      console.error(`取消注册事件 ${event} 出错:`, e);
      return false;
    }
  };

  // 清除所有事件监听器
  const offAll = () => {
    try {
      console.log("清除所有事件监听器");
      // 遍历所有事件类型
      for (const eventType in eventHandlers) {
        if (eventHandlers.hasOwnProperty(eventType)) {
          // 清空该事件类型的所有处理程序
          eventHandlers[eventType] = [];
        }
      }
      return true;
    } catch (e) {
      console.error("清除所有事件监听器出错:", e);
      return false;
    }
  };

  // 声明清理函数
  let cleanupFunction = async () => {
    console.log("清理WebSocket资源");

    // 调用完全销毁方法
    destroyCompletely();

    console.log("WebSocket资源清理完成");
  };

  // 同步全局状态到本地
  const syncFromGlobal = () => {
    // 如果全局状态已初始化，则使用它
    if (instance.isInitialized) {
      connectionStatus.value = instance.status;
      nodeName.value = instance.nodeName;
      onlineCount.value = instance.onlineCount;
      onlineUsers.value = instance.onlineUsers;
      currentTopic.value = instance.currentTopic;
      reconnectCount.value = instance.reconnectCount;
      autoReconnect.value = instance.autoReconnect;
    }
  };

  // 初始同步
  syncFromGlobal();

  // 在组件卸载时自动清理
  onUnmounted(() => {
    cleanupFunction();
  });

  return {
    // 状态
    connectionStatus,
    nodeName,
    onlineCount,
    onlineUsers,
    currentTopic,
    reconnectCount,
    autoReconnect,

    // 页面状态
    isPageVisible,

    // 方法
    initWebSocket,
    closeWebSocket,
    sendMessage,
    manualReconnect,
    cleanup: cleanupFunction,
    destroyCompletely, // 导出完全销毁方法

    // 事件系统
    on,
    emit,
    off, // 导出取消注册事件的方法
    offAll, // 导出清除所有事件的方法
  };
}
